/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.palomino.servicios;

/**
 *
 * @author JONATHAN
 */
public class Fecha {

    String sFecha = "";
    String sFormato = "";

    public Fecha() {
    }

    public Fecha(String psFecha, String psFormato) {
        sFecha = ponMascaraFecha(psFormato, psFecha);
        sFormato = psFormato;
    }

    public void setFecha(String psFecha, String psFormato) {
        sFecha = ponMascaraFecha(psFormato, psFecha);
        sFormato = psFormato;
    }

    public java.sql.Date getFechaSQL() {
        return getFechaSQL(sFecha, sFormato);
    }

    public java.sql.Date getFechaSQL(String psFecha, String psFormato) {
        sFecha = psFecha;
        sFormato = psFormato;
        int liDia = 1;
        int liMes = 1;
        int liAno = 1900;
        for (int x = 0; x < psFormato.length(); x++) {
            if (psFormato.substring(x).startsWith("dd")) {
                liDia = Integer.parseInt(psFecha.substring(x, x + 2));
                x++;
                continue;
            }
            if (psFormato.substring(x).startsWith("MM")) {
                liMes = Integer.parseInt(psFecha.substring(x, x + 2)) - 1;
                x++;
                continue;
            }
            if (psFormato.substring(x).startsWith("yyyy")) {
                liAno = Integer.parseInt(psFecha.substring(x)) - 1900;
                x += 3;
                continue;
            }
        }
        return new java.sql.Date(liAno, liMes, liDia);
    }

    public void setFechaSQL(String psDate, String psFormato) {
        sFormato = psFormato;
        setFechaSQL(psDate);
    }

    //2002-12-10 00:00:00.0
    public void setFechaSQL(String psDate) {
        String psFechaNueva = "";
        for (int x = 0; x < sFormato.length(); x++) {
            if (sFormato.substring(x).startsWith("dd")) {
                psFechaNueva += psDate.substring(8, 10);

                x += 1;
                continue;
            }
            if (sFormato.substring(x).startsWith("MM")) {
                psFechaNueva += psDate.substring(5, 7);
                x += 1;
                continue;
            }
            if (sFormato.substring(x).startsWith("yyyy")) {
                psFechaNueva += psDate.substring(0, 4);
                x += 3;
                continue;
            }
            psFechaNueva += sFormato.charAt(x);
        }
        sFecha = psFechaNueva;
    }

    public void setFormato(String psFormato) {
        sFormato = psFormato;
    }

    public String getFormato() {
        return sFormato;
    }

    public void setFecha(String psFecha) {
        sFecha = psFecha;
    }

    public String getFecha() {
        return sFecha;
    }

    /**
     * Elimina de la fecha aquellos caracteres que no sean números o letras.
     *
     * @param psFecha fecha con máscara
     * @return fecha sin la máscara
     * @see #ponMascaraFecha(java.lang.String, java.lang.String)
     */
    public static String quitaMascaraFecha(String psFecha) {
        String lsQueda = "";
        for (int x = 0; x < psFecha.length(); x++) {
            //Admitimos letras y numeros
            if (Character.isDigit(psFecha.charAt(x))) {
                lsQueda += psFecha.charAt(x);
            }
            if (Character.isLetter(psFecha.charAt(x))) {
                lsQueda += psFecha.charAt(x);
            }
        }
        return lsQueda;
    }

    /**
     * Pone máscara a una fecha. <br> La máscara es una secuencia de caracteres
     * que determinan cómo será mostrada la fecha. Hay una serie de de letras
     * tienen un significado especial <ul> <li> M signfica mes <li> d significa
     * dia <li> y significa año <li> h significa horas <li> m significa minutos
     * <li> s significa segundos <li> G significa era (BC / AD) </ul> Los
     * caracteres que no son especiales se significan a sí mismos. Por ejemplo:
     * la máscara "dd.MM : año yyyy" da como resultado "18.09 : año 2000"
     * <br>Para mas información acerca de la máscara consultar la clase
     * SimpleDateFormat.
     *
     * @param psMascara Máscara de la fecha
     * @param psFecha Fecha en formato cadena
     * @return Fecha enmascarada según psMascara
     * @exception java.text.ParseException Si la máscara de fecha esta mal
     * establecida
     * @exception Exception Excepción genérica
     * @see #quitaMascaraFecha(java.lang.String)
     * @see #validaFecha(int, int, int)
     */
    public static String ponMascaraFecha(String psMascara, String psFecha) {
        // Las tres mascaras que permite un TTextField: 'dd-MM-yyyy', 'HH:mm', 'MM-yyyy'

        String lsQuedaFecha = quitaMascaraFecha(psFecha);
        if (psMascara.equals("HH:mm")) {
            if (lsQuedaFecha.length() < 4) {
                return "";   // Numero erroneo de caracteres
            } else {
                if (!validaHora(Integer.parseInt(lsQuedaFecha.substring(0, 2)),
                        Integer.parseInt(lsQuedaFecha.substring(2)))) {
                    return ""; // Hora Invalida
                }
            }
        }
        if (psMascara.equals("MM-yyyy")) {
            if (lsQuedaFecha.length() < 6) {
                return "";    // Numero erroneo de caracteres    
            } else {
                if (!validaFecha(Integer.parseInt(lsQuedaFecha.substring(0, 2)),
                        Integer.parseInt(lsQuedaFecha.substring(2, 6)))) {
                    return "";  // Fecha Invalida
                }
            }
        }
        if (psMascara.equals("dd-MM-yyyy")) {
            if (lsQuedaFecha.length() < 8) {
                return "";      // Numero erroneo de caracteres    
            } else {
                if (!validaFecha(Integer.parseInt(lsQuedaFecha.substring(0, 2)),
                        Integer.parseInt(lsQuedaFecha.substring(2, 4)),
                        Integer.parseInt(lsQuedaFecha.substring(4, 8)))) {
                    return "";    // Fecha Invalida
                }
            }
        }
        // Por aqui solo pasará si supera todas las validaciones
        String lsNueva = "";
        for (int x = 0, y = 0; x < psMascara.length() && y < lsQuedaFecha.length(); x++) {
            if (Character.isLetter(psMascara.charAt(x))) {
                lsNueva += lsQuedaFecha.charAt(y++);
            } else {
                lsNueva += psMascara.charAt(x);
            }
        }
        return lsNueva;
    }

    /**
     * Metodo que valida una si una fecha es válida entre los años 1900 y 2100
     *
     * @param dd. Entero que contiene el dia de la fecha a validar
     * @param mm. Entero que contiene el mes de la fecha a validar
     * @param aaaa. Entero que contiene el año de la fecha a validar
     * @return boolean. true o false si el dd, mm, aaaa recibidos conforman una
     * fecha valida
     */
    public static boolean validaFecha(int dd, int mm, int aaaa) {
        int diasmes;

        /* Calcular los dias del mes */
        switch (mm) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                diasmes = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                diasmes = 30;
                break;
            case 2: // Comprobar si el año es bisiesto
                if ((aaaa % 4 == 0) && (aaaa % 100 != 0) || (aaaa % 400 == 0)) {
                    diasmes = 29;
                } else {
                    diasmes = 28;
                }
                break;
            default:
                return false; //Fecha invalida
        }
        if ((dd >= 1 && dd <= diasmes) && (aaaa >= 1900 && aaaa <= 2100)) {
            return true;    //Fecha valida
        } else {
            return false;   //Fecha invalida
        }
    }

    /**
     * Metodo que valida una si una fecha es válida entre los años 1900 y 2100
     *
     * @param mm. Entero que contiene el mes de la fecha a validar
     * @param aaaa. Entero que contiene el año de la fecha a validar
     * @return boolean. true o false si el mm, aaaa recibidos conforman una
     * fecha valida
     */
    public static boolean validaFecha(int mm, int aaaa) {
        int diasmes;

        /* Calcular los dias del mes */
        if (mm < 1 || mm > 12) {
            return false;
        }
        if ((aaaa >= 1900 && aaaa <= 2100)) {
            return true;    //Fecha valida
        } else {
            return false;   //Fecha invalida
        }
    }

    /**
     * Metodo que valida si una hora es correcta en formato
     *
     * @param hh. Horas ( Formato 24H )
     * @param mm. Minutos
     * @return boolean. true o false si las horas y minutos son correctas
     */
    public static boolean validaHora(int hh, int mm) {
        int horas = 60;
        int minutos = 60;

        if ((hh >= 0 && hh <= 24) && (mm >= 0 && mm <= 60)) {
            return true;
        } else {
            return false; // Horas o minutos fuera de rango 
        }
    }
}